<head><meta charset="UTF-8"></head><h1 class="heading">事务简介</h1>
<p>标签： MySQL是怎样运行的</p>
<hr>
<h2 class="heading">事务的起源</h2>
<p>对于大部分程序员来说，他们的任务就是把现实世界的业务场景映射到数据库世界。比如银行为了存储人们的账户信息会建立一个<code>account</code>表：</p>
<pre><code class="hljs bash" lang="bash">CREATE TABLE account (
    id INT NOT NULL AUTO_INCREMENT COMMENT <span class="hljs-string">'自增id'</span>,
    name VARCHAR(100) COMMENT <span class="hljs-string">'客户名称'</span>,
    balance INT COMMENT <span class="hljs-string">'余额'</span>,
    PRIMARY KEY (id)
) Engine=InnoDB CHARSET=utf8;
</code></pre><p>狗哥和猫爷是一对好基友，他们都到银行开一个账户，他们在现实世界中拥有的资产就会体现在数据库世界的<code>account</code>表中。比如现在狗哥有<code>11</code>元，猫爷只有<code>2</code>元，那么现实中的这个情况映射到数据库的<code>account</code>表就是这样：</p>
<pre><code class="hljs bash" lang="bash">+----+--------+---------+
| id | name   | balance |
+----+--------+---------+
|  1 | 狗哥   |      11 |
|  2 | 猫爷   |       2 |
+----+--------+---------+
</code></pre><p>在某个特定的时刻，狗哥猫爷这些家伙在银行所拥有的资产是一个特定的值，这些特定的值也可以被描述为账户在这个特定的时刻现实世界的一个状态。随着时间的流逝，狗哥和猫爷可能陆续进行向账户中存钱、取钱或者向别人转账等操作，这样他们账户中的余额就可能发生变动，<span style="color:red">每一个操作都相当于现实世界中账户的一次状态转换</span>。数据库世界作为现实世界的一个映射，自然也要进行相应的变动。不变不知道，一变吓一跳，现实世界中一些看似很简单的状态转换，映射到数据库世界却不是那么容易的。比方说有一次猫爷在赌场赌博输了钱，急忙打电话给狗哥要借10块钱，不然那些看场子的就会把自己剁了。现实世界中的狗哥走向了ATM机，输入了猫爷的账号以及10元的转账金额，然后按下确认，狗哥就拔卡走人了。对于数据库世界来说，相当于执行了下边这两条语句：</p>
<pre><code class="hljs bash" lang="bash">UPDATE account SET balance = balance - 10 WHERE id = 1;
UPDATE account SET balance = balance + 10 WHERE id = 2;
</code></pre><p>但是这里头有个问题，上述两条语句只执行了一条时忽然服务器断电了咋办？把狗哥的钱扣了，但是没给猫爷转过去，那猫爷还是逃脱不了被砍死的噩运～  即使对于单独的一条语句，我们前边唠叨<code>Buffer Pool</code>时也说过，在对某个页面进行读写访问时，都会先把这个页面加载到<code>Buffer Pool</code>中，之后如果修改了某个页面，也不会立即把修改同步到磁盘，而只是把这个修改了的页面加到<code>Buffer Pool</code>的<code>flush链表</code>中，在之后的某个时间点才会刷新到磁盘。如果在将修改过的页刷新到磁盘之前系统崩溃了那岂不是猫爷还是要被砍死？或者在刷新磁盘的过程中（只刷新部分数据到磁盘上）系统奔溃了猫爷也会被砍死？</p>
<p>怎么才能保证让可怜的猫爷不被砍死呢？其实再仔细想想，我们只是想<span style="color:red">让某些数据库操作符合现实世界中状态转换的规则</span>而已，设计数据库的大叔们仔细盘算了盘算，现实世界中状态转换的规则有好几条，待我们慢慢道来。</p>
<h3 class="heading">原子性（Atomicity）</h3>
<p>现实世界中转账操作是一个不可分割的操作，也就是说要么压根儿就没转，要么转账成功，不能存在中间的状态，也就是转了一半的这种情况。设计数据库的大叔们把这种要么全做，要么全不做的规则称之为<code>原子性</code>。但是在现实世界中的一个不可分割的操作却可能对应着数据库世界若干条不同的操作，数据库中的一条操作也可能被分解成若干个步骤（比如先修改缓存页，之后再刷新到磁盘等），最要命的是在任何一个可能的时间都可能发生意想不到的错误（可能是数据库本身的错误，或者是操作系统错误，甚至是直接断电之类的）而使操作执行不下去，所以猫爷可能会被砍死。为了保证在数据库世界中某些操作的原子性，设计数据库的大叔需要费一些心机来保证如果在执行操作的过程中发生了错误，把已经做了的操作恢复成没执行之前的样子，这也是我们后边章节要仔细唠叨的内容。</p>
<h3 class="heading">隔离性（Isolation）</h3>
<p>现实世界中的两次状态转换应该是互不影响的，比如说狗哥向猫爷同时进行的两次金额为5元的转账（假设可以在两个ATM机上同时操作）。那么最后狗哥的账户里肯定会少10元，猫爷的账户里肯定多了10元。但是到对应的数据库世界中，事情又变的复杂了一些。为了简化问题，我们粗略的假设狗哥向猫爷转账5元的过程是由下边几个步骤组成的：</p>
<ul>
<li>
<p>步骤一：读取狗哥账户的余额到变量A中，这一步骤简写为<code>read(A)</code>。</p>
</li>
<li>
<p>步骤二：将狗哥账户的余额减去转账金额，这一步骤简写为<code>A = A - 5</code>。</p>
</li>
<li>
<p>步骤三：将狗哥账户修改过的余额写到磁盘里，这一步骤简写为<code>write(A)</code>。</p>
</li>
<li>
<p>步骤四：读取猫爷账户的余额到变量B，这一步骤简写为<code>read(B)</code>。</p>
</li>
<li>
<p>步骤五：将猫爷账户的余额加上转账金额，这一步骤简写为<code>B = B + 5</code>。</p>
</li>
<li>
<p>步骤六：将猫爷账户修改过的余额写到磁盘里，这一步骤简写为<code>write(B)</code>。</p>
</li>
</ul>
<p>我们将狗哥向猫爷同时进行的两次转账操作分别称为<code>T1</code>和<code>T2</code>，在现实世界中<code>T1</code>和<code>T2</code>是应该没有关系的，可以先执行完<code>T1</code>，再执行<code>T2</code>，或者先执行完<code>T2</code>，再执行<code>T1</code>，对应的数据库操作就像这样：</p>
<p></p><figure><img alt="image_1d1stskva1vp4a7f5kjdi7pf19.png-74.2kB" src="https://user-gold-cdn.xitu.io/2019/4/1/169d7fd5bcbcc82f?w=1041&amp;h=519&amp;f=png&amp;s=75962"><figcaption></figcaption></figure><br>
但是很不幸，真实的数据库中<code>T1</code>和<code>T2</code>的操作可能交替执行，比如这样：<p></p>
<p></p><figure><img alt="image_1d1sut47o5tk13ul4gb1qibuct2j.png-67.9kB" src="https://user-gold-cdn.xitu.io/2019/4/1/169d7fd5bd2cf68b?w=838&amp;h=530&amp;f=png&amp;s=69515"><figcaption></figcaption></figure><p></p>
<p>如果按照上图中的执行顺序来进行两次转账的话，最终狗哥的账户里还剩<code>6</code>元钱，相当于只扣了5元钱，但是猫爷的账户里却成了<code>12</code>元钱，相当于多了10元钱，这银行岂不是要亏死了？</p>
<p>所以对于现实世界中状态转换对应的某些数据库操作来说，不仅要保证这些操作以<code>原子性</code>的方式执行完成，而且要保证其它的状态转换不会影响到本次状态转换，这个规则被称之为<code>隔离性</code>。这时设计数据库的大叔们就需要采取一些措施来让访问相同数据（上例中的A账户和B账户）的不同状态转换（上例中的<code>T1</code>和<code>T2</code>）对应的数据库操作的执行顺序有一定规律，这也是我们后边章节要仔细唠叨的内容。</p>
<h3 class="heading">一致性（Consistency）</h3>
<p>我们生活的这个世界存在着形形色色的约束，比如身份证号不能重复，性别只能是男或者女，高考的分数只能在0～750之间，人民币面值最大只能是100（现在是2019年），红绿灯只有3种颜色，房价不能为负的，学生要听老师话，吧啦吧啦有点儿扯远了～ 只有符合这些约束的数据才是有效的，比如有个小孩儿跟你说他高考考了1000分，你一听就知道他胡扯呢。数据库世界只是现实世界的一个映射，现实世界中存在的约束当然也要在数据库世界中有所体现。如果数据库中的数据全部符合现实世界中的约束（all defined rules），我们说这些数据就是一致的，或者说符合<code>一致性</code>的。</p>
<p>如何保证数据库中数据的一致性（就是符合所有现实世界的约束）呢？这其实靠两方面的努力：</p>
<ul>
<li>
<p>数据库本身能为我们保证一部分一致性需求（就是数据库自身可以保证一部分现实世界的约束永远有效）。</p>
<p>我们知道<code>MySQL</code>数据库可以为表建立主键、唯一索引、外键、声明某个列为<code>NOT NULL</code>来拒绝<code>NULL</code>值的插入。比如说当我们对某个列建立唯一索引时，如果插入某条记录时该列的值重复了，那么<code>MySQL</code>就会报错并且拒绝插入。除了这些我们已经非常熟悉的保证一致性的功能，<code>MySQL</code>还支持<code>CHECK</code>语法来自定义约束，比如这样：</p>
<pre><code class="hljs bash" lang="bash">CREATE TABLE account (
    id INT NOT NULL AUTO_INCREMENT COMMENT <span class="hljs-string">'自增id'</span>,
    name VARCHAR(100) COMMENT <span class="hljs-string">'客户名称'</span>,
    balance INT COMMENT <span class="hljs-string">'余额'</span>,
    PRIMARY KEY (id),
    CHECK (balance &gt;= 0) 
);
</code></pre><p>上述例子中的<code>CHECK</code>语句本意是想规定<code>balance</code>列不能存储小于0的数字，对应的现实世界的意思就是银行账户余额不能小于0。但是很遗憾，<span style="color:red">MySQL仅仅支持CHECK语法，但实际上并没有一点卵用</span>，也就是说即使我们使用上述带有<code>CHECK</code>子句的建表语句来创建<code>account</code>表，那么在后续插入或更新记录时，<code>MySQL</code>并不会去检查<code>CHECK</code>子句中的约束是否成立。</p>
<blockquote class="warning"><p>小贴士：

其它的一些数据库，比如SQL Server或者Oracle支持的CHECK语法是有实实在在的作用的，每次进行插入或更新记录之前都会检查一下数据是否符合CHECK子句中指定的约束条件是否成立，如果不成立的话就会拒绝插入或更新。
</p></blockquote><p>虽然<code>CHECK</code>子句对一致性检查没什么卵用，但是我们还是可以通过定义触发器的方式来自定义一些约束条件以保证数据库中数据的一致性。</p>
<blockquote class="warning"><p>小贴士：

触发器是MySQL基础内容中的知识，本书是一本MySQL进阶的书籍，如果你不了解触发器，那恐怕要找本基础内容的书籍来看看了。
</p></blockquote></li>
<li>
<p>更多的一致性需求需要靠写业务代码的程序员自己保证。</p>
<p>为建立现实世界和数据库世界的对应关系，理论上应该把现实世界中的所有约束都反应到数据库世界中，但是很不幸，在更改数据库数据时进行一致性检查是一个耗费性能的工作，比方说我们为<code>account</code>表建立了一个触发器，每当插入或者更新记录时都会校验一下<code>balance</code>列的值是不是大于0，这就会影响到插入或更新的速度。仅仅是校验一行记录符不符合一致性需求倒也不是什么大问题，有的一致性需求简直变态，比方说银行会建立一张代表账单的表，里边儿记录了每个账户的每笔交易，<span style="color:red">每一笔交易完成后，都需要保证整个系统的余额等于所有账户的收入减去所有账户的支出</span>。如果在数据库层面实现这个一致性需求的话，每次发生交易时，都需要将所有的收入加起来减去所有的支出，再将所有的账户余额加起来，看看两个值相不相等。这不是搞笑呢么，如果账单表里有几亿条记录，光是这个校验的过程可能就要跑好几个小时，也就是说你在煎饼摊买个煎饼，使用银行卡付款之后要等好几个小时才能提示付款成功，这样的性能代价是完全承受不起的。</p>
<p>现实生活中复杂的一致性需求比比皆是，而由于性能问题把一致性需求交给数据库去解决这是不现实的，所以这个锅就甩给了业务端程序员。比方说我们的<code>account</code>表，我们也可以不建立触发器，只要编写业务的程序员在自己的业务代码里判断一下，当某个操作会将<code>balance</code>列的值更新为小于0的值时，就不执行该操作就好了嘛！</p>
</li>
</ul>
<p>我们前边唠叨的<code>原子性</code>和<code>隔离性</code>都会对<code>一致性</code>产生影响，比如我们现实世界中转账操作完成后，有一个<code>一致性</code>需求就是参与转账的账户的总的余额是不变的。如果数据库不遵循<code>原子性</code>要求，也就是转了一半就不转了，也就是说给狗哥扣了钱而没给猫爷转过去，那最后就是不符合一致性需求的；类似的，如果数据库不遵循<code>隔离性</code>要求，就像我们前边唠叨<code>隔离性</code>时举的例子中所说的，最终狗哥账户中扣的钱和猫爷账户中涨的钱可能就不一样了，也就是说不符合<code>一致性</code>需求了。所以说，<span style="color:red">数据库某些操作的原子性和隔离性都是保证一致性的一种手段，在操作执行完成后保证符合所有既定的约束则是一种结果</span>。那满足<code>原子性</code>和<code>隔离性</code>的操作一定就满足<code>一致性</code>么？那倒也不一定，比如说狗哥要转账20元给猫爷，虽然在满足<code>原子性</code>和<code>隔离性</code>，但转账完成了之后狗哥的账户的余额就成负的了，这显然是不满足<code>一致性</code>的。那不满足<code>原子性</code>和<code>隔离性</code>的操作就一定不满足<code>一致性</code>么？这也不一定，只要最后的结果符合所有现实世界中的约束，那么就是符合<code>一致性</code>的。</p>
<h3 class="heading">持久性（Durability）</h3>
<p>当现实世界的一个状态转换完成后，这个转换的结果将永久的保留，这个规则被设计数据库的大叔们称为<code>持久性</code>。比方说狗哥向猫爷转账，当ATM机提示转账成功了，就意味着这次账户的状态转换完成了，狗哥就可以拔卡走人了。如果当狗哥走掉之后，银行又把这次转账操作给撤销掉，恢复到没转账之前的样子，那猫爷不就惨了，又得被砍死了，所以这个<code>持久性</code>是非常重要的。</p>
<p>当把现实世界的状态转换映射到数据库世界时，<code>持久性</code>意味着该转换对应的数据库操作所修改的数据都应该在磁盘上保留下来，不论之后发生了什么事故，本次转换造成的影响都不应该被丢失掉（要不然猫爷还是会被砍死）。</p>
<h2 class="heading">事务的概念</h2>
<p>为了方便大家记住我们上边唠叨的现实世界状态转换过程中需要遵守的4个特性，我们把<code>原子性</code>（<code>Atomicity</code>）、<code>隔离性</code>（<code>Isolation</code>）、<code>一致性</code>（<code>Consistency</code>）和<code>持久性</code>（<code>Durability</code>）这四个词对应的英文单词首字母提取出来就是<code>A</code>、<code>I</code>、<code>C</code>、<code>D</code>，稍微变换一下顺序可以组成一个完整的英文单词：<code>ACID</code>。想必大家都是学过初高中英语的，<code>ACID</code>是英文<code>酸</code>的意思，以后我们提到<code>ACID</code>这个词儿，大家就应该想到原子性、一致性、隔离性、持久性这几个规则。另外，设计数据库的大叔为了方便起见，把需要保证<code>原子性</code>、<code>隔离性</code>、<code>一致性</code>和<code>持久性</code>的一个或多个数据库操作称之为一个<code>事务</code>（英文名是：<code>transaction</code>）。</p>
<p>我们现在知道<code>事务</code>是一个抽象的概念，它其实对应着一个或多个数据库操作，设计数据库的大叔根据这些操作所执行的不同阶段把<code>事务</code>大致上划分成了这么几个状态：</p>
<ul>
<li>
<p>活动的（active）</p>
<p>事务对应的数据库操作正在执行过程中时，我们就说该事务处在<code>活动的</code>状态。</p>
</li>
<li>
<p>部分提交的（partially committed）</p>
<p>当事务中的最后一个操作执行完成，但由于操作都在内存中执行，所造成的影响并没有刷新到磁盘时，我们就说该事务处在<code>部分提交的</code>状态。</p>
</li>
<li>
<p>失败的（failed）</p>
<p>当事务处在<code>活动的</code>或者<code>部分提交的</code>状态时，可能遇到了某些错误（数据库自身的错误、操作系统错误或者直接断电等）而无法继续执行，或者人为的停止当前事务的执行，我们就说该事务处在<code>失败的</code>状态。</p>
</li>
<li>
<p>中止的（aborted）</p>
<p>如果事务执行了半截而变为<code>失败的</code>状态，比如我们前边唠叨的狗哥向猫爷转账的事务，当狗哥账户的钱被扣除，但是猫爷账户的钱没有增加时遇到了错误，从而当前事务处在了<code>失败的</code>状态，那么就需要把已经修改的狗哥账户余额调整为未转账之前的金额，换句话说，就是要撤销失败事务对当前数据库造成的影响。书面一点的话，我们把这个撤销的过程称之为<code>回滚</code>。当<code>回滚</code>操作执行完毕时，也就是数据库恢复到了执行事务之前的状态，我们就说该事务处在了<code>中止的</code>状态。</p>
</li>
<li>
<p>提交的（committed）</p>
<p>当一个处在<code>部分提交的</code>状态的事务将修改过的数据都同步到磁盘上之后，我们就可以说该事务处在了<code>提交的</code>状态。</p>
</li>
</ul>
<p>随着事务对应的数据库操作执行到不同阶段，事务的状态也在不断变化，一个基本的状态转换图如下所示：</p>
<p></p><figure><img alt="image_1d7bvq3401fpe1eum1d7qkop1f479.png-69.6kB" src="https://user-gold-cdn.xitu.io/2019/4/1/169d7fd5bd4ce2f1?w=791&amp;h=483&amp;f=png&amp;s=71252"><figcaption></figcaption></figure><br>
从图中大家也可以看出了，<span style="color:red">只有当事务处于提交的或者中止的状态时，一个事务的生命周期才算是结束了</span>。对于已经提交的事务来说，该事务对数据库所做的修改将永久生效，对于处于中止状态的事务，该事务对数据库所做的所有修改都会被回滚到没执行该事务之前的状态。<p></p>
<blockquote class="warning"><p>小贴士：

此贴士处纯属扯犊子，与正文没啥关系，纯属吐槽。大家知道我们的计算机术语基本上全是从英文翻译成中文的，事务的英文是transaction，英文直译就是交易，买卖的意思，交易就是买的人付钱，卖的人交货，不能付了钱不交货，交了货不付钱把，所以交易本身就是一种不可分割的操作。不知道是哪位大神把transaction翻译成了事务（我想估计是他们也想不出什么更好的词儿，只能随便找一个了），事务这个词儿完全没有交易、买卖的意思，所以大家理解起来也会比较困难，外国人理解transaction可能更好理解一点吧～ 
</p></blockquote><h2 class="heading">MySQL中事务的语法</h2>
<p>我们说<code>事务</code>的本质其实只是一系列数据库操作，只不过这些数据库操作符合<code>ACID</code>特性而已，那么<code>MySQL</code>中如何将某些操作放到一个事务里去执行的呢？我们下边就来重点唠叨唠叨。</p>
<h3 class="heading">开启事务</h3>
<p>我们可以使用下边两种语句之一来开启一个事务：</p>
<ul>
<li>
<p><code>BEGIN [WORK];</code></p>
<p><code>BEGIN</code>语句代表开启一个事务，后边的单词<code>WORK</code>可有可无。开启事务后，就可以继续写若干条语句，这些语句都属于刚刚开启的这个事务。</p>
<pre><code class="hljs bash" lang="bash">mysql&gt; BEGIN;
Query OK, 0 rows affected (0.00 sec)

mysql&gt; 加入事务的语句...
</code></pre></li>
<li>
<p><code>START TRANSACTION;</code></p>
<p><code>START TRANSACTION</code>语句和<code>BEGIN</code>语句有着相同的功效，都标志着开启一个事务，比如这样：</p>
<pre><code class="hljs bash" lang="bash">mysql&gt; START TRANSACTION;
Query OK, 0 rows affected (0.00 sec)

mysql&gt; 加入事务的语句...
</code></pre><p>不过比<code>BEGIN</code>语句牛逼一点儿的是，可以在<code>START TRANSACTION</code>语句后边跟随几个<code>修饰符</code>，就是它们几个：</p>
<ul>
<li>
<p><code>READ ONLY</code>：标识当前事务是一个只读事务，也就是属于该事务的数据库操作只能读取数据，而不能修改数据。</p>
<blockquote class="warning"><p>小贴士：其实只读事务中只是不允许修改那些其他事务也能访问到的表中的数据，对于临时表来说（我们使用CREATE TMEPORARY TABLE创建的表），由于它们只能在当前会话中可见，所以只读事务其实也是可以对临时表进行增、删、改操作的。
</p></blockquote></li>
<li>
<p><code>READ WRITE</code>：标识当前事务是一个读写事务，也就是属于该事务的数据库操作既可以读取数据，也可以修改数据。</p>
</li>
<li>
<p><code>WITH CONSISTENT SNAPSHOT</code>：启动一致性读（先不用关心啥是个一致性读，后边的章节才会唠叨）。</p>
</li>
</ul>
<p>比如我们想开启一个只读事务的话，直接把<code>READ ONLY</code>这个修饰符加在<code>START TRANSACTION</code>语句后边就好，比如这样：</p>
<pre><code class="hljs bash" lang="bash">START TRANSACTION READ ONLY;
</code></pre><p>如果我们想在<code>START TRANSACTION</code>后边跟随多个<code>修饰符</code>的话，可以使用逗号将<code>修饰符</code>分开，比如开启一个只读事务和一致性读，就可以这样写：</p>
<pre><code class="hljs bash" lang="bash">START TRANSACTION READ ONLY, WITH CONSISTENT SNAPSHOT;
</code></pre><p>或者开启一个读写事务和一致性读，就可以这样写：</p>
<pre><code class="hljs bash" lang="bash">START TRANSACTION READ WRITE, WITH CONSISTENT SNAPSHOT
</code></pre><p>不过这里需要大家注意的一点是，<code>READ ONLY</code>和<code>READ WRITE</code>是用来设置所谓的事务<code>访问模式</code>的，就是以只读还是读写的方式来访问数据库中的数据，一个事务的访问模式不能同时既设置为<code>只读</code>的也设置为<code>读写</code>的，所以我们不能同时把<code>READ ONLY</code>和<code>READ WRITE</code>放到<code>START TRANSACTION</code>语句后边。另外，如果我们不显式指定事务的访问模式，那么该事务的访问模式就是<code>读写</code>模式。</p>
</li>
</ul>
<h3 class="heading">提交事务</h3>
<p>开启事务之后就可以继续写需要放到该事务中的语句了，当最后一条语句写完了之后，我们就可以提交该事务了，提交的语句也很简单：</p>
<pre><code class="hljs bash" lang="bash">COMMIT [WORK]
</code></pre><p><code>COMMIT</code>语句就代表提交一个事务，后边的<code>WORK</code>可有可无。比如我们上边说狗哥给猫爷转10元钱其实对应<code>MySQL</code>中的两条语句，我们就可以把这两条语句放到一个事务中，完整的过程就是这样：</p>
<pre><code class="hljs bash" lang="bash">mysql&gt; BEGIN;
Query OK, 0 rows affected (0.00 sec)

mysql&gt; UPDATE account SET balance = balance - 10 WHERE id = 1;
Query OK, 1 row affected (0.02 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql&gt; UPDATE account SET balance = balance + 10 WHERE id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql&gt; COMMIT;
Query OK, 0 rows affected (0.00 sec)
</code></pre><h3 class="heading">手动中止事务</h3>
<p>如果我们写了几条语句之后发现上边的某条语句写错了，我们可以手动的使用下边这个语句来将数据库恢复到事务执行之前的样子：</p>
<pre><code class="hljs bash" lang="bash">ROLLBACK [WORK]
</code></pre><p><code>ROLLBACK</code>语句就代表中止并回滚一个事务，后边的<code>WORK</code>可有可无类似的。比如我们在写狗哥给猫爷转账10元钱对应的<code>MySQL</code>语句时，先给狗哥扣了10元，然后一时大意只给猫爷账户上增加了1元，此时就可以使用<code>ROLLBACK</code>语句进行回滚，完整的过程就是这样：</p>
<pre><code class="hljs bash" lang="bash">mysql&gt; BEGIN;
Query OK, 0 rows affected (0.00 sec)

mysql&gt; UPDATE account SET balance = balance - 10 WHERE id = 1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql&gt; UPDATE account SET balance = balance + 1 WHERE id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql&gt; ROLLBACK;
Query OK, 0 rows affected (0.00 sec)
</code></pre><p>这里需要强调一下，<code>ROLLBACK</code>语句是我们程序员手动的去回滚事务时才去使用的，如果事务在执行过程中遇到了某些错误而无法继续执行的话，事务自身会自动的回滚。</p>
<blockquote class="warning"><p>小贴士：

我们这里所说的开启、提交、中止事务的语法只是针对使用黑框框时通过mysql客户端程序与服务器进行交互时控制事务的语法，如果大家使用的是别的客户端程序，比如JDBC之类的，那需要参考相应的文档来看看如何控制事务。
</p></blockquote><h3 class="heading">支持事务的存储引擎</h3>
<p><code>MySQL</code>中并不是所有存储引擎都支持事务的功能，目前只有<code>InnoDB</code>和<code>NDB</code>存储引擎支持（NDB存储引擎不是我们的重点），如果某个事务中包含了修改使用不支持事务的存储引擎的表，那么对该使用不支持事务的存储引擎的表所做的修改将无法进行回滚。比方说我们有两个表，<code>tbl1</code>使用支持事务的存储引擎<code>InnoDB</code>，<code>tbl2</code>使用不支持事务的存储引擎<code>MyISAM</code>，它们的建表语句如下所示：</p>
<pre><code class="hljs bash" lang="bash">CREATE TABLE tbl1 (
    i int
) engine=InnoDB;

CREATE TABLE tbl2 (
    i int
) ENGINE=MyISAM;
</code></pre><p>我们看看先开启一个事务，写一条插入语句后再回滚该事务，<code>tbl1</code>和<code>tbl2</code>的表现有什么不同：</p>
<pre><code class="hljs bash" lang="bash">mysql&gt; SELECT * FROM tbl1;
Empty <span class="hljs-built_in">set</span> (0.00 sec)

mysql&gt; BEGIN;
Query OK, 0 rows affected (0.00 sec)

mysql&gt; INSERT INTO tbl1 VALUES(1);
Query OK, 1 row affected (0.00 sec)

mysql&gt; ROLLBACK;
Query OK, 0 rows affected (0.00 sec)

mysql&gt; SELECT * FROM tbl1;
Empty <span class="hljs-built_in">set</span> (0.00 sec)
</code></pre><p>可以看到，对于使用支持事务的存储引擎的<code>tbl1</code>表来说，我们在插入一条记录再回滚后，<code>tbl1</code>就恢复到没有插入记录时的状态了。再看看<code>tbl2</code>表的表现：</p>
<pre><code class="hljs bash" lang="bash">mysql&gt; SELECT * FROM tbl2;
Empty <span class="hljs-built_in">set</span> (0.00 sec)

mysql&gt; BEGIN;
Query OK, 0 rows affected (0.00 sec)

mysql&gt; INSERT INTO tbl2 VALUES(1);
Query OK, 1 row affected (0.00 sec)

mysql&gt; ROLLBACK;
Query OK, 0 rows affected, 1 warning (0.01 sec)

mysql&gt; SELECT * FROM tbl2;
+------+
| i    |
+------+
|    1 |
+------+
1 row <span class="hljs-keyword">in</span> <span class="hljs-built_in">set</span> (0.00 sec)
</code></pre><p>可以看到，虽然我们使用了<code>ROLLBACK</code>语句来回滚事务，但是插入的那条记录还是留在了<code>tbl2</code>表中。</p>
<h3 class="heading">自动提交</h3>
<p><code>MySQL</code>中有一个系统变量<code>autocommit</code>：</p>
<pre><code class="hljs bash" lang="bash">mysql&gt; SHOW VARIABLES LIKE <span class="hljs-string">'autocommit'</span>;
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+
1 row <span class="hljs-keyword">in</span> <span class="hljs-built_in">set</span> (0.01 sec)
</code></pre><p>可以看到它的默认值为<code>ON</code>，也就是说默认情况下，如果我们不显式的使用<code>START TRANSACTION</code>或者<code>BEGIN</code>语句开启一个事务，那么每一条语句都算是一个独立的事务，这种特性称之为事务的<code>自动提交</code>。假如我们在狗哥向猫爷转账10元时不以<code>START TRANSACTION</code>或者<code>BEGIN</code>语句显式的开启一个事务，那么下边这两条语句就相当于放到两个独立的事务中去执行：</p>
<pre><code class="hljs bash" lang="bash">UPDATE account SET balance = balance - 10 WHERE id = 1;
UPDATE account SET balance = balance + 10 WHERE id = 2;
</code></pre><p>当然，如果我们想关闭这种<code>自动提交</code>的功能，可以使用下边两种方法之一：</p>
<ul>
<li>
<p>显式的的使用<code>START TRANSACTION</code>或者<code>BEGIN</code>语句开启一个事务。</p>
<p>这样在本次事务提交或者回滚前会暂时关闭掉自动提交的功能。</p>
</li>
<li>
<p>把系统变量<code>autocommit</code>的值设置为<code>OFF</code>，就像这样：</p>
<pre><code class="hljs bash" lang="bash">SET autocommit = OFF;
</code></pre><p>这样的话，我们写入的多条语句就算是属于同一个事务了，直到我们显式的写出<code>COMMIT</code>语句来把这个事务提交掉，或者显式的写出<code>ROLLBACK</code>语句来把这个事务回滚掉。</p>
</li>
</ul>
<h3 class="heading">隐式提交</h3>
<p>当我们使用<code>START TRANSACTION</code>或者<code>BEGIN</code>语句开启了一个事务，或者把系统变量<code>autocommit</code>的值设置为<code>OFF</code>时，事务就不会进行<code>自动提交</code>，但是如果我们输入了某些语句之后就会<code>悄悄的</code>提交掉，就像我们输入了<code>COMMIT</code>语句了一样，这种因为某些特殊的语句而导致事务提交的情况称为<code>隐式提交</code>，这些会导致事务隐式提交的语句包括：</p>
<ul>
<li>
<p>定义或修改数据库对象的数据定义语言（Data definition language，缩写为：<code>DDL</code>）。</p>
<p>所谓的数据库对象，指的就是<code>数据库</code>、<code>表</code>、<code>视图</code>、<code>存储过程</code>等等这些东西。当我们使用<code>CREATE</code>、<code>ALTER</code>、<code>DROP</code>等语句去修改这些所谓的数据库对象时，就会隐式的提交前边语句所属于的事务，就像这样：</p>
<pre><code class="hljs bash" lang="bash">BEGIN;

SELECT ... <span class="hljs-comment"># 事务中的一条语句</span>
UPDATE ... <span class="hljs-comment"># 事务中的一条语句</span>
... <span class="hljs-comment"># 事务中的其它语句</span>

CREATE TABLE ... <span class="hljs-comment"># 此语句会隐式的提交前边语句所属于的事务</span>
</code></pre></li>
<li>
<p>隐式使用或修改<code>mysql</code>数据库中的表</p>
<p>当我们使用<code>ALTER USER</code>、<code>CREATE USER</code>、<code>DROP USER</code>、<code>GRANT</code>、<code>RENAME USER</code>、<code>REVOKE</code>、<code>SET PASSWORD</code>等语句时也会隐式的提交前边语句所属于的事务。</p>
</li>
<li>
<p>事务控制或关于锁定的语句</p>
<p>当我们在一个事务还没提交或者回滚时就又使用<code>START TRANSACTION</code>或者<code>BEGIN</code>语句开启了另一个事务时，会隐式的提交上一个事务，比如这样：</p>
<pre><code class="hljs bash" lang="bash">BEGIN;

SELECT ... <span class="hljs-comment"># 事务中的一条语句</span>
UPDATE ... <span class="hljs-comment"># 事务中的一条语句</span>
... <span class="hljs-comment"># 事务中的其它语句</span>

BEGIN; <span class="hljs-comment"># 此语句会隐式的提交前边语句所属于的事务</span>
</code></pre><p>或者当前的<code>autocommit</code>系统变量的值为<code>OFF</code>，我们手动把它调为<code>ON</code>时，也会隐式的提交前边语句所属的事务。</p>
<p>或者使用<code>LOCK TABLES</code>、<code>UNLOCK TABLES</code>等关于锁定的语句也会隐式的提交前边语句所属的事务。</p>
</li>
<li>
<p>加载数据的语句</p>
<p>比如我们使用<code>LOAD DATA</code>语句来批量往数据库中导入数据时，也会隐式的提交前边语句所属的事务。</p>
</li>
<li>
<p>关于<code>MySQL</code>复制的一些语句</p>
<p>使用<code>START SLAVE</code>、<code>STOP SLAVE</code>、<code>RESET SLAVE</code>、<code>CHANGE MASTER TO</code>等语句时也会隐式的提交前边语句所属的事务。</p>
</li>
<li>
<p>其它的一些语句</p>
<p>使用<code>ANALYZE TABLE</code>、<code>CACHE INDEX</code>、<code>CHECK TABLE</code>、<code>FLUSH</code>、 <code>LOAD INDEX INTO CACHE</code>、<code>OPTIMIZE TABLE</code>、<code>REPAIR TABLE</code>、<code>RESET</code>等语句也会隐式的提交前边语句所属的事务。</p>
</li>
</ul>
<blockquote class="warning"><p>小贴士：

上边提到的一些语句，如果你都认识并且知道是干嘛用的那再好不过了，不认识也不要气馁，这里写出来只是为了内容的完整性，把可能会导致事务隐式提交的情况都列举一下，具体每个语句都是干嘛用的等我们遇到了再说哈。
</p></blockquote><h3 class="heading">保存点</h3>
<p>如果你开启了一个事务，并且已经敲了很多语句，忽然发现上一条语句有点问题，你只好使用<code>ROLLBACK</code>语句来让数据库状态恢复到事务执行之前的样子，然后一切从头再来，总有一种一夜回到解放前的感觉。所以设计数据库的大叔们提出了一个<code>保存点</code>（英文：<code>savepoint</code>）的概念，就是在事务对应的数据库语句中打几个点，我们在调用<code>ROLLBACK</code>语句时可以指定会滚到哪个点，而不是回到最初的原点。定义保存点的语法如下：</p>
<pre><code class="hljs bash" lang="bash">SAVEPOINT 保存点名称;
</code></pre><p>当我们想回滚到某个保存点时，可以使用下边这个语句（下边语句中的单词<code>WORK</code>和<code>SAVEPOINT</code>是可有可无的）：</p>
<pre><code class="hljs bash" lang="bash">ROLLBACK [WORK] TO [SAVEPOINT] 保存点名称;
</code></pre><p>不过如果<code>ROLLBACK</code>语句后边不跟随保存点名称的话，会直接回滚到事务执行之前的状态。</p>
<p>如果我们想删除某个保存点，可以使用这个语句：</p>
<pre><code class="hljs bash" lang="bash">RELEASE SAVEPOINT 保存点名称;
</code></pre><p>下边还是以狗哥向猫爷转账10元的例子展示一下<code>保存点</code>的用法，在执行完扣除狗哥账户的钱<code>10</code>元的语句之后打一个<code>保存点</code>：</p>
<pre><code class="hljs bash" lang="bash">mysql&gt; SELECT * FROM account;
+----+--------+---------+
| id | name   | balance |
+----+--------+---------+
|  1 | 狗哥   |      11 |
|  2 | 猫爷   |       2 |
+----+--------+---------+
2 rows <span class="hljs-keyword">in</span> <span class="hljs-built_in">set</span> (0.00 sec)

mysql&gt; BEGIN;
Query OK, 0 rows affected (0.00 sec)

mysql&gt; UPDATE account SET balance = balance - 10 WHERE id = 1;
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql&gt; SAVEPOINT s1;    <span class="hljs-comment"># 一个保存点</span>
Query OK, 0 rows affected (0.00 sec)

mysql&gt; SELECT * FROM account;
+----+--------+---------+
| id | name   | balance |
+----+--------+---------+
|  1 | 狗哥   |       1 |
|  2 | 猫爷   |       2 |
+----+--------+---------+
2 rows <span class="hljs-keyword">in</span> <span class="hljs-built_in">set</span> (0.00 sec)

mysql&gt; UPDATE account SET balance = balance + 1 WHERE id = 2; <span class="hljs-comment"># 更新错了</span>
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql&gt; ROLLBACK TO s1;  <span class="hljs-comment"># 回滚到保存点s1处</span>
Query OK, 0 rows affected (0.00 sec)

mysql&gt; SELECT * FROM account;
+----+--------+---------+
| id | name   | balance |
+----+--------+---------+
|  1 | 狗哥   |       1 |
|  2 | 猫爷   |       2 |
+----+--------+---------+
2 rows <span class="hljs-keyword">in</span> <span class="hljs-built_in">set</span> (0.00 sec)
</code></pre>